﻿package core.image.psd
{
    import __AS3__.vec.*;
    import flash.utils.*;

    public class PSDFile extends Object
    {
        public var header:Header;
        public var ImageCompresssion:int = 0;
        public var Valid:Boolean = false;
        public var HasIndex:Boolean = false;
        public var IndexLength:uint = 0;
        public var IndexData:ByteArray;
        public var ImageResources:Vector.<ImageResource>;
        public var Layers:Vector.<Layer>;
        public var AbsoluteAlpha:Boolean = false;
        public var GlobalLayerMaskData:ByteArray;
        public var Data:Array;

        public function PSDFile()
        {
            this.header = new Header();
            this.IndexData = new ByteArray();
            this.ImageResources = new Vector.<ImageResource>;
            this.Layers = new Vector.<Layer>;
            this.GlobalLayerMaskData = new ByteArray();
            this.Data = [];
            return;
        }// end function

        public static function Load(core.image.psd:ByteArray) : PSDFile
        {
            var _loc_2:ImageResource = null;
            var _loc_3:int = 0;
            var _loc_4:uint = 0;
            var _loc_5:int = 0;
            var _loc_6:int = 0;
            var _loc_7:uint = 0;
            var _loc_8:int = 0;
            var _loc_9:Layer = null;
            var _loc_10:Channel = null;
            var _loc_11:int = 0;
            var _loc_12:int = 0;
            var _loc_18:int = 0;
            var _loc_13:Number = 0;
            var _loc_14:* = new PSDFile;
            var _loc_15:* = new ByteArrayReader(core.image.psd);
            _loc_14.Valid = Boolean(_loc_15.ReadString(4) == "8BPS");
            _loc_14.header.Version = _loc_15.ReadInt16();
            _loc_15.Position = _loc_15.Position + 6;
            _loc_14.header.Channels = _loc_15.ReadInt16();
            _loc_14.header.Rows = _loc_15.ReadInt32();
            _loc_14.header.Columns = _loc_15.ReadInt32();
            _loc_14.header.Depth = _loc_15.ReadInt16();
            _loc_14.header.ColorMode = _loc_15.ReadInt16();
            _loc_14.IndexLength = _loc_15.ReadUInt32();
            if (_loc_14.IndexLength > 0)
            {
                _loc_14.IndexData = _loc_15.Read(_loc_14.IndexLength);
            }
            var _loc_16:* = _loc_15.ReadUInt32();
            if (_loc_16 > 0)
            {
                _loc_13 = _loc_15.Position;
                while (_loc_15.Position - _loc_13 < _loc_16)
                {
                    
                    _loc_2 = ImageResource.Load(_loc_15);
                    switch(_loc_2.Id)
                    {
                        case 1005:
                        {
                            break;
                        }
                        case 1033:
                        case 1036:
                        {
                            break;
                        }
                        case 1006:
                        {
                            break;
                        }
                        default:
                        {
                            break;
                        }
                    }
                }
                _loc_15.Position = _loc_13 + _loc_16;
            }
            var _loc_17:* = _loc_15.ReadUInt32();
            if (_loc_17 > 0)
            {
                _loc_3 = _loc_15.Position;
                _loc_4 = _loc_15.ReadUInt32();
                if (_loc_4 > 0)
                {
                    _loc_5 = _loc_15.Position;
                    _loc_6 = _loc_15.ReadInt16();
                    if (_loc_6 < 0)
                    {
                        _loc_14.AbsoluteAlpha = true;
                        _loc_6 = Math.abs(_loc_6);
                    }
                    if (_loc_6 !== 0)
                    {
                        _loc_8 = 0;
                        while (_loc_8 < _loc_6)
                        {
                            
                            _loc_14.Layers.push(Layer.Load(_loc_15));
                            _loc_8++;
                        }
                        for each (_loc_9 in _loc_14.Layers)
                        {
                            
                            for each (_loc_10 in _loc_9.Channels)
                            {
                                
                                if (_loc_10.Id !== -2)
                                {
                                    Channel.LoadPixelData(_loc_15, _loc_10, _loc_14, _loc_9);
                                }
                            }
                            Mask.LoadPixelData(_loc_15, _loc_9.MaskData, _loc_9, _loc_14);
                        }
                        if (_loc_15.Position % 2 == 1)
                        {
                            _loc_15.ReadByte();
                        }
                        _loc_15.Position = _loc_5 + _loc_4;
                    }
                    _loc_7 = _loc_15.ReadInt32();
                    if (_loc_7 > 0)
                    {
                        _loc_14.GlobalLayerMaskData = _loc_15.Read(int(_loc_7));
                    }
                }
                _loc_15.Position = _loc_3 + _loc_17;
            }
            _loc_14.ImageCompresssion = _loc_15.ReadInt16();
            if (_loc_14.ImageCompresssion === 1)
            {
                _loc_15.Position = _loc_15.Position + _loc_14.header.Rows * _loc_14.header.Channels * 2;
            }
            while (_loc_18 < _loc_14.header.Channels)
            {
                
                _loc_14.Data[_loc_18] = new ByteArray();
                switch(_loc_14.ImageCompresssion)
                {
                    case 0:
                    {
                        _loc_14.Data[_loc_18] = _loc_15.Read(_loc_14.header.Rows * _loc_14.header.Columns);
                        break;
                    }
                    case 1:
                    {
                        _loc_11 = 0;
                        while (_loc_11 < _loc_14.header.Rows)
                        {
                            
                            _loc_12 = _loc_11 * _loc_14.header.Columns;
                            ImageHelper.DecodeRleRow(_loc_15, _loc_14.Data[_loc_18], _loc_14.header.Rows * _loc_14.header.Columns, _loc_12, _loc_14.header.Columns);
                            _loc_11++;
                        }
                        break;
                    }
                    default:
                    {
                        break;
                    }
                }
                _loc_18++;
            }
            return _loc_14;
        }// end function

    }
}
